/**
 * 单元测试集成处理器
 * 将单元测试生成能力集成到 AiChat 界面
 */
import * as vscode from 'vscode';
import { LLMFactory } from '../../../core/llm/llmFactory';
import { Logger } from '../../../src/logger/Logger';
import { AgentModeExecutor } from './Interactive/AgentModeExecutor';
import { GNFileManager } from './GNFileManager';
import * as path from 'path';

export class UnitTestIntegrationHandler {
    private agentExecutor: AgentModeExecutor | undefined;
    private currentDocument: vscode.TextDocument | undefined;
    private currentPosition: vscode.Position | undefined;
    private pendingFileActions: Map<string, {
        fileType: 'test' | 'gn';
        filePath: string;
        content?: string;
        action: 'create' | 'modify';
    }> = new Map();

    constructor(
        private context: vscode.ExtensionContext,
        private llmFactory: LLMFactory,
        private sendMessage: (messageType: string, data: any) => void
    ) {}

    /**
     * 处理生成单元测试请求（仅使用Agent模式）
     */
    public async handleGenerateRequest(data: { 
        mode: 'agent';
        filePath?: string;
        selectedText?: string;
        isWholeFile?: boolean;
    }): Promise<void> {
        try {
            const editor = vscode.window.activeTextEditor;
            if (!editor) {
                this.sendMessage('utError', { error: '请先打开一个 C/C++ 文件' });
                return;
            }

            const document = editor.document;
            if (document.languageId !== 'cpp' && document.languageId !== 'c') {
                this.sendMessage('utError', { error: '此功能仅支持 C/C++ 文件' });
                return;
            }

            this.currentDocument = document;
            this.currentPosition = editor.selection.active;

            Logger.info(`[UT Integration] 🤖 启动 Agent 模式`);
            Logger.info(`[UT Integration]    文件: ${document.uri.fsPath}`);
            Logger.info(`[UT Integration]    位置: 行 ${this.currentPosition.line}, 列 ${this.currentPosition.character}`);
            Logger.info(`[UT Integration]    选中文本长度: ${data.selectedText ? data.selectedText.length : 0}`);
            
            // Agent 模式：自动执行，流式显示步骤
            this.agentExecutor = new AgentModeExecutor(
                this.llmFactory,
                (msg) => this.handleExecutorMessage(msg)
            );

            // 执行自动化流程
            await this.agentExecutor.execute(
                document,
                this.currentPosition,
                data.selectedText  // 传递选中的代码文本
            );
            
            Logger.info(`[UT Integration] ✅ Agent 模式执行完成`);

        } catch (error) {
            Logger.error(`生成单元测试失败: ${error}`);
            this.sendMessage('utError', { error: String(error) });
        }
    }

    /**
     * 处理用户的聊天消息（Agent 模式的迭代优化）
     */
    public async handleChatMessage(message: string): Promise<void> {
        // 检查是否有可用的执行器
        if (!this.agentExecutor) {
            this.sendMessage('utError', { error: '会话已失效，请重新生成' });
            return;
        }

        try {
            Logger.info(`[UT Integration] 使用 Agent 模式处理对话`);
            await this.agentExecutor.handleChatMessage(message);
            
            this.sendMessage('utComplete', {
                message: '代码已优化完成'
            });
        } catch (error) {
            Logger.error(`处理聊天消息失败: ${error}`);
            this.sendMessage('utError', { error: String(error) });
        }
    }

    /**
     * 应用生成的测试代码（Agent 模式已自动处理，此方法保留用于兼容）
     */
    public async applyTestCode(): Promise<void> {
        if (!this.agentExecutor || !this.currentDocument) {
            vscode.window.showErrorMessage('没有可应用的测试代码');
            return;
        }

        try {
            // Agent 模式自己处理文件创建
            Logger.info(`[UT Integration] Agent 模式已处理文件创建`);
            vscode.window.showInformationMessage('Agent 模式会自动处理文件创建，无需手动应用');
            return;

        } catch (error) {
            Logger.error(`应用测试代码失败: ${error}`);
            vscode.window.showErrorMessage(`应用失败: ${error}`);
        }
    }

    /**
     * 处理执行器消息
     */
    private handleExecutorMessage(msg: any): void {
        switch (msg.type) {
            case 'thinking':
                // 思考消息暂不显示
                break;
            case 'code-chunk':
                this.sendMessage('utCodeChunk', { content: msg.content });
                break;
            case 'text-chunk':
                // 普通文本流式输出（用于对话回复）
                this.sendMessage('utTextChunk', { content: msg.content });
                break;
            case 'info':
                // 发送信息消息到前端
                this.sendMessage('utInfo', { 
                    level: msg.level || 'info',
                    message: msg.message 
                });
                break;
            case 'file-action':
                // 保存文件操作到待处理队列
                this.pendingFileActions.set(msg.actionId, {
                    fileType: msg.fileType,
                    filePath: msg.filePath,
                    content: msg.content,
                    action: msg.action
                });
                
                // 发送文件操作请求到前端
                this.sendMessage('utFileAction', {
                    actionId: msg.actionId,
                    fileType: msg.fileType,
                    filePath: msg.filePath,
                    displayPath: msg.displayPath,
                    content: msg.content,
                    action: msg.action
                });
                break;
            case 'file-info':
                // 发送文件信息（只读，只有查看按钮）
                Logger.info(`[UT Integration] 📤 转发文件信息到前端`);
                Logger.info(`[UT Integration]    类型: ${msg.fileType}`);
                Logger.info(`[UT Integration]    标签: ${msg.label}`);
                Logger.info(`[UT Integration]    显示路径: ${msg.displayPath}`);
                Logger.info(`[UT Integration]    实际路径: ${msg.filePath}`);
                
                this.sendMessage('utFileInfo', {
                    fileType: msg.fileType,
                    filePath: msg.filePath,
                    displayPath: msg.displayPath,
                    label: msg.label
                });
                
                Logger.info(`[UT Integration] ✅ utFileInfo 消息已发送`);
                break;
            default:
                Logger.info(`[UT Integration] Unhandled message type: ${msg.type}`);
        }
    }

    /**
     * 处理用户对文件操作的响应（采纳/拒绝）
     */
    public async handleFileActionResponse(data: { 
        actionId: string; 
        decision: 'accept' | 'reject' 
    }): Promise<void> {
        const fileAction = this.pendingFileActions.get(data.actionId);
        
        if (!fileAction) {
            Logger.warn(`[UT Integration] 未找到文件操作: ${data.actionId}`);
            return;
        }

        if (data.decision === 'reject') {
            // 用户拒绝，从队列中移除
            this.pendingFileActions.delete(data.actionId);
            Logger.info(`[UT Integration] 用户拒绝了文件操作: ${fileAction.filePath}`);
            return;
        }

        // 用户采纳，执行文件操作
        try {
            if (fileAction.fileType === 'test' && fileAction.content) {
                // 写入测试文件
                const testDir = path.dirname(fileAction.filePath);
                const fs = require('fs');
                
                // 确保目录存在
                if (!fs.existsSync(testDir)) {
                    fs.mkdirSync(testDir, { recursive: true });
                }
                
                // 写入文件
                fs.writeFileSync(fileAction.filePath, fileAction.content, 'utf8');
                Logger.info(`[UT Integration] 测试文件已创建: ${fileAction.filePath}`);
                
                // 打开文件
                const doc = await vscode.workspace.openTextDocument(fileAction.filePath);
                await vscode.window.showTextDocument(doc);
                
                vscode.window.showInformationMessage(`测试文件已创建: ${path.basename(fileAction.filePath)}`);
                
            } else if (fileAction.fileType === 'gn') {
                // 处理 GN 文件
                // 注意：目前 Agent 模式会将 GN 修改发送过来，但内容可能需要从执行器获取
                // 这里暂时只是一个占位符，实际的 GN 修改逻辑可能需要进一步完善
                Logger.info(`[UT Integration] GN 文件操作被采纳: ${fileAction.filePath}`);
                vscode.window.showInformationMessage(`GN 配置已更新`);
            }
            
            // 从队列中移除
            this.pendingFileActions.delete(data.actionId);
            
        } catch (error) {
            Logger.error(`[UT Integration] 应用文件操作失败: ${error}`);
            vscode.window.showErrorMessage(`应用失败: ${error}`);
        }
    }

    /**
     * 暂停当前生成操作
     */
    public pauseCurrentOperation(): void {
        if (this.agentExecutor) {
            Logger.info(`[UT Integration] ⏸️ 暂停生成`);
            this.agentExecutor.pauseCurrentOperation();
        } else {
            Logger.warn(`[UT Integration] 没有正在进行的操作可以暂停`);
        }
    }

    /**
     * 继续当前生成操作
     */
    public resumeCurrentOperation(): void {
        if (this.agentExecutor) {
            Logger.info(`[UT Integration] ▶️ 继续生成`);
            this.agentExecutor.resumeCurrentOperation();
        } else {
            Logger.warn(`[UT Integration] 没有暂停的操作可以继续`);
        }
    }

    /**
     * 取消当前生成操作
     */
    public cancelCurrentOperation(): void {
        if (this.agentExecutor) {
            Logger.info(`[UT Integration] ❌ 取消生成`);
            this.agentExecutor.cancelCurrentOperation();
        } else {
            Logger.warn(`[UT Integration] 没有正在进行的操作可以取消`);
        }
    }

    /**
     * 获取当前操作状态
     */
    public getCurrentState(): { isRunning: boolean; isPaused: boolean } {
        if (this.agentExecutor) {
            return this.agentExecutor.getCurrentState();
        }
        return { isRunning: false, isPaused: false };
    }

}

